Neighborhood filter kernels caching/race condition fixes - #1768

The neighborhood gufuncs are built with ``cache=True``, but the cache never
hit: every process recompiled all nine kernels and appended a fresh set of
entries to the index, which grew without bound (over a thousand files in a
working checkout).

The cause is that ``_make_kernel`` closed each kernel over its reducer. Numba
keys a cached function on a hash of its closure, and a ``Dispatcher``
serializes with a ``uuid4`` regenerated in every process, so the key differed
in every process. Numba reports no error for this -- it writes the cache and
silently misses it. All nine kernels also shared one cache file, since the
closure made them one function as far as numba's locator was concerned.

Give each reduction a module-level kernel body instead, and apply
``guvectorize`` to it on first call. A module-level body has no closure, so its
key is stable, and it reaches its reducer as a global, which numba resolves at
compile time and leaves out of the key. Each body also gets its own cache file.
Kernels are now compiled once per machine rather than once per process.

Compilation stays lazy. ``guvectorize`` compiles at decoration time when given
explicit signatures, so decorating at module scope would rebuild every kernel
during ``import uxarray`` and start numba's threading layer, leaving a thread
pool that makes forks unsafe -- the regression
``test_no_numba_kernels_built_on_import`` guards against.

Replace ``functools.cache`` with a double-checked lock while here. It does not
hold a lock across the call it memoizes, so under ``dask="parallelized"`` every
worker thread that reached a kernel before the first build finished started its
own full compilation, serialized behind numba's global compiler lock. A 12-chunk
reduction compiled the same kernel 12 times; it now compiles once.

The bodies are spelled out rather than generated because the deduplication one
would reach for -- a single shared body taking the reducer as an argument --
makes the reducer a dynamic global, which numba refuses to cache at all. The
gather is shared through ``_widest``/``_gather`` instead, leaving only the
reducer name different between bodies.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

for more information, see https://pre-commit.ci